
/**
 * 
 *  file add for RGK new UI solution by anxiang.xiao  20160506
 *  this class is used to define  mode icon view extends from TwoStateImageView
 */


package com.android.camera.ui;


import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.TransitionDrawable;
import android.media.ThumbnailUtils;
import android.util.AttributeSet;
import android.view.ViewGroup.LayoutParams;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;

import com.android.camera.Log;



// add from XCRoundRectImageView
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.Bitmap.Config;
import android.graphics.Color;
// add end

public class RGK_RotateImageView extends TwoStateImageView implements Rotatable {
	
	  private static final String TAG = "RGK_RotateImageView";

	    private static final int ANIMATION_SPEED = 270; // 270 deg/sec

	    private int mCurrentDegree = 0; // [0, 359]
	    private int mStartDegree = 0;
	    private int mTargetDegree = 0;

	    private boolean mClockwise = false;
	    private boolean mEnableAnimation = true;

	    private long mAnimationStartTime = 0;
	    private long mAnimationEndTime = 0;
	    
	    // add from XCRoundRectImageView
	    private Paint paint;
	    private String paintText ="hello";
	    // add end
	
	    public RGK_RotateImageView(Context context, AttributeSet attrs) {
	        super(context, attrs);
	        
	        paint  = new Paint();
	    }

	    public RGK_RotateImageView(Context context) {
	        this(context, null);
	    }
	    
	    public RGK_RotateImageView(Context context, AttributeSet attrs, int defStyle) {  
	       // super(context, attrs, defStyle); 
	    	super(context, attrs);
	        paint  = new Paint();
	    }  

	    
	    public void setDrawText(String txt)
	    {
	    	paintText = txt;
	    }
	    
	 // Rotate the view counter-clockwise
	    @Override
	    public void setOrientation(int degree, boolean animation) {
	        Log.d(TAG, "setOrientation(" + degree + ", " + animation + ") mOrientation="
	                + mTargetDegree);
	        mEnableAnimation = animation;
	        // make sure in the range of [0, 359]
	        degree = degree >= 0 ? degree % 360 : degree % 360 + 360;
	        if (degree == mTargetDegree) {
	            return;
	        }

	        mTargetDegree = degree;
	        if (mEnableAnimation) {
	            mStartDegree = mCurrentDegree;
	            mAnimationStartTime = AnimationUtils.currentAnimationTimeMillis();

	            int diff = mTargetDegree - mCurrentDegree;
	            diff = diff >= 0 ? diff : 360 + diff; // make it in range [0, 359]

	            // Make it in range [-179, 180]. That's the shorted distance between
	            // the
	            // two angles
	            diff = diff > 180 ? diff - 360 : diff;

	            mClockwise = diff >= 0;
	            mAnimationEndTime = mAnimationStartTime + Math.abs(diff) * 1000 / ANIMATION_SPEED;
	        } else {
	            mCurrentDegree = mTargetDegree;
	        }

	        invalidate();
	    }
	    
	    @Override
	    protected void onDraw(Canvas canvas) {
	        Drawable drawable = getDrawable();
	        if (drawable == null) {
	            Log.e(TAG, "drawable == null, return");
	            return;
	        }

	        Rect bounds = drawable.getBounds();
	        int w = bounds.right - bounds.left;
	        int h = bounds.bottom - bounds.top;

	        if (w == 0 || h == 0) {
	            Log.e(TAG, "w == 0 || h == 0, return");
	            return; // nothing to draw
	        }

	        if (mCurrentDegree != mTargetDegree) {
	            long time = AnimationUtils.currentAnimationTimeMillis();
	            if (time < mAnimationEndTime) {
	                int deltaTime = (int) (time - mAnimationStartTime);
	                int degree = mStartDegree + ANIMATION_SPEED * (mClockwise ? deltaTime : -deltaTime)
	                        / 1000;
	                degree = degree >= 0 ? degree % 360 : degree % 360 + 360;
	                mCurrentDegree = degree;
	                invalidate();
	            } else {
	                mCurrentDegree = mTargetDegree;
	            }
	        }

	        int left = getPaddingLeft();
	        int top = getPaddingTop();
	        int right = getPaddingRight();
	        int bottom = getPaddingBottom();
	        int width = getWidth() - left - right;
	        int height = getHeight() - top - bottom;

	        int saveCount = canvas.getSaveCount();

	        // Scale down the image first if required.
	        if ((getScaleType() == ImageView.ScaleType.FIT_CENTER) && ((width < w) || (height < h))) {
	            float ratio = Math.min((float) width / w, (float) height / h);
	            canvas.scale(ratio, ratio, width / 2.0f, height / 2.0f);
	        }
	        canvas.translate(left + width / 2, top + height / 2);
	        canvas.rotate(-mCurrentDegree);
	        canvas.translate(-w / 2, -h / 2);
	        
	        // add start
	        Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();  
            // Bitmap b = getRoundBitmap(bitmap, 20);  
	        Bitmap b = bitmap;
            final Rect rectSrc = new Rect(0, 0, width, height);  
            final Rect rectDest = new Rect(0,0,width,height);
            paint.reset();  
            canvas.drawBitmap(b, rectSrc, rectDest, paint);  
            
            
            Log.i(TAG, "width ="+width +",height ="+height +",left ="+left +",right ="+right +",top="+top+",bottom="+bottom);
            int textSize = 20;
            
           
            paint.setColor(Color.WHITE);
         
            paint.setTextSize((int)(textSize/1.3));

            if (paintText.length() >= 9)
            	canvas.drawText(paintText, rectDest.centerX() - width / 3, rectDest.bottom, paint);
            else
            	canvas.drawText(paintText, rectDest.centerX() - width / 5, rectDest.bottom, paint);
	        // add end
            
            // remove 
	       // drawable.draw(canvas);
	        
	        canvas.restoreToCount(saveCount);
	    }

	    /*
	    @Override  
	    protected void onDraw(Canvas canvas) {  
	  
	        Drawable drawable = getDrawable();  
	        if (null != drawable) {  
	            Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();  
	            Bitmap b = getRoundBitmap(bitmap, 20);  
	            final Rect rectSrc = new Rect(0, 0, b.getWidth(), b.getHeight());  
	            final Rect rectDest = new Rect(0,0,getWidth(),getHeight());
	            paint.reset();  
	            canvas.drawBitmap(b, rectSrc, rectDest, paint);  
	  
	        } else {  
	            super.onDraw(canvas);  
	        }  
	    }  */
	    
	    
	    private Bitmap getRoundBitmap(Bitmap bitmap, int roundPx) {  
	        Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),  
	                bitmap.getHeight(), Config.ARGB_8888);  
	        Canvas canvas = new Canvas(output);  
	          
	        final int color = 0xff424242;
	       
	        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());  
	        final RectF rectF = new RectF(rect);
	        paint.setAntiAlias(true);  
	        canvas.drawARGB(0, 0, 0, 0);  
	        paint.setColor(color);  
	        int x = bitmap.getWidth(); 
	        
	        canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
	        paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));  
	        canvas.drawBitmap(bitmap, rect, rect, paint);  
	        return output;  
	        
	        
	    }  
	    
	    

	    private Bitmap mThumb;
	    private Drawable[] mThumbs;
	    private TransitionDrawable mThumbTransition;

	    public void setBitmap(Bitmap bitmap) {
	        // Make sure uri and original are consistently both null or both
	        // non-null.
	        if (bitmap == null) {
	            mThumb = null;
	            mThumbs = null;
	            setImageDrawable(null);
	            // setVisibility(GONE);
	            return;
	        }

	        LayoutParams param = getLayoutParams();
	        final int miniThumbWidth = param.width - getPaddingLeft() - getPaddingRight();
	        final int miniThumbHeight = param.height - getPaddingTop() - getPaddingBottom();
	        mThumb = ThumbnailUtils.extractThumbnail(bitmap, miniThumbWidth, miniThumbHeight);
	        if (mThumbs == null || !mEnableAnimation) {
	            mThumbs = new Drawable[2];
	            mThumbs[1] = new BitmapDrawable(getContext().getResources(), mThumb);
	            setImageDrawable(mThumbs[1]);
	        } else {
	            mThumbs[0] = mThumbs[1];
	            mThumbs[1] = new BitmapDrawable(getContext().getResources(), mThumb);
	            mThumbTransition = new TransitionDrawable(mThumbs);
	            setImageDrawable(mThumbTransition);
	            mThumbTransition.startTransition(500);
	        }
	        setVisibility(VISIBLE);
	    }




}